home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / DISK / XHDI-125.ZOO / xhdi.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-21  |  8.0 KB  |  421 lines
  1. /*
  2.     @(#)XHDI/xhdi.c
  3.     
  4.     Julian F. Reschke, 21. August 1994
  5.     
  6.     Bindings for the XHDI functions
  7.     --- NOT FULLY TESTED, USE AT YOUR OWN RISK ---
  8.  
  9.     Important:
  10.     
  11.     Do calls only if XHGetVersion() was successful
  12. */
  13.  
  14. #include <stddef.h>
  15. #include <stdio.h>
  16. #include <string.h>
  17. #include <tos.h>
  18.  
  19. #include "xhdi.h"
  20.  
  21. #define XHDIMAGIC 0x27011992L
  22.  
  23. typedef LONG cdecl (*cookie_fun)(UWORD opcode,...);
  24.  
  25. static long
  26. cookieptr (void)
  27. {
  28.     return *((long *)0x5a0);
  29. }
  30.  
  31. static int
  32. getcookie (long cookie, long *p_value)
  33. {
  34.     long *cookiejar = (long *)Supexec (cookieptr);
  35.  
  36.     if (!cookiejar) return 0;
  37.  
  38.     do
  39.     {
  40.         if (cookiejar[0] == cookie)
  41.         {
  42.             if (p_value) *p_value = cookiejar[1];
  43.             return 1;
  44.         }
  45.         else
  46.             cookiejar = &(cookiejar[2]);
  47.     } while (cookiejar[-2]);
  48.  
  49.     return 0;
  50. }
  51.  
  52. static cookie_fun
  53. get_fun_ptr (void)
  54. {
  55.     static cookie_fun XHDI = NULL;
  56.     static int have_it = 0;
  57.     
  58.     if (!have_it)
  59.     {
  60.         LONG *magic_test;
  61.     
  62.         getcookie ('XHDI', (LONG *)&XHDI);
  63.         have_it = 1;
  64.  
  65.         /* check magic */
  66.         
  67.         magic_test = (LONG *)XHDI;
  68.         if (magic_test && (magic_test[-1] != XHDIMAGIC))
  69.             XHDI = NULL;
  70.     }
  71.     
  72.     return XHDI;
  73. }
  74.  
  75.  
  76. UWORD
  77. XHGetVersion (void)
  78. {
  79.     cookie_fun XHDI = get_fun_ptr ();
  80.     LONG oldstack = 0;
  81.     UWORD ret = 0;        /* 0: kein Cookie da */
  82.  
  83.     if (!Super ((void *)1L)) oldstack = Super (0L);
  84.     
  85.     if (XHDI)
  86.         ret = (UWORD) XHDI (0);
  87.         
  88.     if (oldstack) Super ((void *)oldstack);
  89.     return ret;
  90. }
  91.  
  92. LONG
  93. XHInqTarget (UWORD major, UWORD minor, ULONG *block_size,
  94.              ULONG *device_flags, char *product_name)
  95. {
  96.     cookie_fun XHDI = get_fun_ptr ();
  97.     LONG oldstack = 0;
  98.     LONG ret;
  99.     
  100.     if (!Super ((void *)1L)) oldstack = Super (0L);
  101.     
  102.     ret = XHDI (1, major, minor, block_size, device_flags,
  103.                 product_name);
  104.         
  105.     if (oldstack) Super ((void *)oldstack);
  106.     return ret;
  107. }
  108.  
  109. LONG
  110. XHReserve (UWORD major, UWORD minor, UWORD do_reserve, UWORD key)
  111. {
  112.     cookie_fun XHDI = get_fun_ptr ();
  113.     LONG oldstack = 0;
  114.     LONG ret;
  115.     
  116.     if (!Super ((void *)1L)) oldstack = Super (0L);
  117.     
  118.     ret = XHDI (2, major, minor, do_reserve, key);
  119.         
  120.     if (oldstack) Super ((void *)oldstack);
  121.     return ret;
  122. }
  123.  
  124. LONG
  125. XHLock (UWORD major, UWORD minor, UWORD do_lock, UWORD key)
  126. {
  127.     cookie_fun XHDI = get_fun_ptr ();
  128.     LONG oldstack = 0;
  129.     LONG ret;
  130.     
  131.     if (!Super ((void *)1L)) oldstack = Super (0L);
  132.     
  133.     ret = XHDI (3, major, minor, do_lock, key);
  134.         
  135.     if (oldstack) Super ((void *)oldstack);
  136.     return ret;
  137. }
  138.  
  139. LONG
  140. XHStop (UWORD major, UWORD minor, UWORD do_stop, UWORD key)
  141. {
  142.     cookie_fun XHDI = get_fun_ptr ();
  143.     LONG oldstack = 0;
  144.     LONG ret;
  145.     
  146.     if (!Super ((void *)1L)) oldstack = Super (0L);
  147.     
  148.     ret = XHDI (4, major, minor, do_stop, key);
  149.         
  150.     if (oldstack) Super ((void *)oldstack);
  151.     return ret;
  152. }
  153.  
  154. LONG
  155. XHEject (UWORD major, UWORD minor, UWORD do_eject, UWORD key)
  156. {
  157.     cookie_fun XHDI = get_fun_ptr ();
  158.     LONG oldstack = 0;
  159.     LONG ret;
  160.     
  161.     if (!Super ((void *)1L)) oldstack = Super (0L);
  162.     
  163.     ret = XHDI (5, major, minor, do_eject, key);
  164.         
  165.     if (oldstack) Super ((void *)oldstack);
  166.     return ret;
  167. }
  168.  
  169. ULONG
  170. XHDrvMap (void)
  171. {
  172.     cookie_fun XHDI = get_fun_ptr ();
  173.     LONG oldstack = 0;
  174.     LONG ret;
  175.     
  176.     if (!Super ((void *)1L)) oldstack = Super (0L);
  177.     
  178.     ret = XHDI (6);
  179.         
  180.     if (oldstack) Super ((void *)oldstack);
  181.     return ret;
  182. }
  183.  
  184. LONG
  185. XHInqDev (UWORD bios_device, UWORD *major, UWORD *minor,
  186.           ULONG *start_sector, BPB *bpb)
  187. {
  188.     cookie_fun XHDI = get_fun_ptr ();
  189.     LONG oldstack = 0;
  190.     LONG ret;
  191.     
  192.     if (!Super ((void *)1L)) oldstack = Super (0L);
  193.     
  194.     ret = XHDI (7, bios_device, major, minor, start_sector, bpb);
  195.         
  196.     if (oldstack) Super ((void *)oldstack);
  197.     return ret;
  198. }
  199.  
  200. LONG
  201. XHInqDriver (UWORD bios_device, char *name, char *version,
  202.     char *company, UWORD *ahdi_version, UWORD *maxIPL)
  203. {
  204.     cookie_fun XHDI = get_fun_ptr ();
  205.     LONG oldstack = 0;
  206.     LONG ret;
  207.     
  208.     if (!Super ((void *)1L)) oldstack = Super (0L);
  209.     
  210.     ret = XHDI (8, bios_device, name, version, company, ahdi_version,
  211.                 maxIPL);
  212.  
  213.     if (oldstack) Super ((void *)oldstack);
  214.     return ret;
  215. }
  216.  
  217. LONG
  218. XHNewCookie (void *newcookie)
  219. {
  220.     cookie_fun XHDI = get_fun_ptr ();
  221.     LONG oldstack = 0;
  222.     LONG ret;
  223.     
  224.     if (!Super ((void *)1L)) oldstack = Super (0L);
  225.     
  226.     ret = XHDI (9, newcookie);
  227.         
  228.     if (oldstack) Super ((void *)oldstack);
  229.     return ret;
  230. }
  231.  
  232. LONG
  233. XHReadWrite (UWORD major, UWORD minor, UWORD rwflag,
  234.              ULONG recno, UWORD count, void *buf)
  235. {
  236.     cookie_fun XHDI = get_fun_ptr ();
  237.     LONG oldstack = 0;
  238.     LONG ret;
  239.     
  240.     if (!Super ((void *)1L)) oldstack = Super (0L);
  241.     
  242.     ret = XHDI (10, major, minor, rwflag, recno, count, buf);
  243.  
  244.     if (oldstack) Super ((void *)oldstack);
  245.     return ret;
  246. }
  247.  
  248. LONG
  249. XHInqTarget2 (UWORD major, UWORD minor, ULONG *block_size,
  250.               ULONG *device_flags, char *product_name,
  251.               UWORD stringlen)
  252. {
  253.     cookie_fun XHDI = get_fun_ptr ();
  254.     LONG oldstack = 0;
  255.     LONG ret;
  256.     
  257.     if (!Super ((void *)1L)) oldstack = Super (0L);
  258.     
  259.     ret = XHDI (11, major, minor, block_size, device_flags,
  260.                 product_name, stringlen);
  261.         
  262.     if (oldstack) Super ((void *)oldstack);
  263.     return ret;
  264. }
  265.  
  266. LONG
  267. XHInqDev2 (UWORD bios_device, UWORD *major, UWORD *minor,
  268.            ULONG *start_sector, BPB *bpb, ULONG *blocks,
  269.            char *partid)
  270. {
  271.     cookie_fun XHDI = get_fun_ptr ();
  272.     LONG oldstack = 0;
  273.     LONG ret;
  274.     
  275.     if (!Super ((void *)1L)) oldstack = Super (0L);
  276.     
  277.     ret = XHDI (12, bios_device, major, minor, start_sector, bpb,
  278.                 blocks, partid);
  279.         
  280.     if (oldstack) Super ((void *)oldstack);
  281.     return ret;
  282. }
  283.  
  284. LONG
  285. XHDriverSpecial (ULONG key1, ULONG key2, UWORD subopcode, void *data)
  286. {
  287.     cookie_fun XHDI = get_fun_ptr ();
  288.     LONG oldstack = 0;
  289.     LONG ret;
  290.     
  291.     if (!Super ((void *)1L)) oldstack = Super (0L);
  292.     
  293.     ret = XHDI (13, key1, key2, subopcode, data);
  294.         
  295.     if (oldstack) Super ((void *)oldstack);
  296.     return ret;
  297. }
  298.  
  299. LONG
  300. XHGetCapacity (UWORD major, UWORD minor, ULONG *blocks, ULONG *bs)
  301. {
  302.     cookie_fun XHDI = get_fun_ptr ();
  303.     LONG oldstack = 0;
  304.     LONG ret;
  305.     
  306.     if (!Super ((void *)1L)) oldstack = Super (0L);
  307.     
  308.     ret = XHDI (14, major, minor, blocks, bs);
  309.         
  310.     if (oldstack) Super ((void *)oldstack);
  311.     return ret;
  312. }
  313.  
  314. LONG
  315. XHMediumChanged (UWORD major, UWORD minor)
  316. {
  317.     cookie_fun XHDI = get_fun_ptr ();
  318.     LONG oldstack = 0;
  319.     LONG ret;
  320.     
  321.     if (!Super ((void *)1L)) oldstack = Super (0L);
  322.     
  323.     ret = XHDI (15, major, minor);
  324.         
  325.     if (oldstack) Super ((void *)oldstack);
  326.     return ret;
  327. }
  328.  
  329. LONG
  330. XHMiNTInfo (UWORD opcode, void *data)
  331. {
  332.     cookie_fun XHDI = get_fun_ptr ();
  333.     LONG oldstack = 0;
  334.     LONG ret;
  335.     
  336.     if (!Super ((void *)1L)) oldstack = Super (0L);
  337.     
  338.     ret = XHDI (16, opcode, data);
  339.         
  340.     if (oldstack) Super ((void *)oldstack);
  341.     return ret;
  342. }
  343.  
  344. LONG
  345. XHDOSLimits (UWORD which, ULONG limit)
  346. {
  347.     cookie_fun XHDI = get_fun_ptr ();
  348.     LONG oldstack = 0;
  349.     LONG ret;
  350.     
  351.     if (!Super ((void *)1L)) oldstack = Super (0L);
  352.     
  353.     ret = XHDI (17, which, limit);
  354.         
  355.     if (oldstack) Super ((void *)oldstack);
  356.     return ret;
  357. }
  358.  
  359. LONG
  360. XHLastAccess (UWORD major, UWORD minor, ULONG *ms)
  361. {
  362.     cookie_fun XHDI = get_fun_ptr ();
  363.     LONG oldstack = 0;
  364.     LONG ret;
  365.     
  366.     if (!Super ((void *)1L)) oldstack = Super (0L);
  367.     
  368.     ret = XHDI (18, major, minor, ms);
  369.         
  370.     if (oldstack) Super ((void *)oldstack);
  371.     return ret;
  372. }
  373.  
  374. LONG
  375. XHReaccess (UWORD major, UWORD minor)
  376. {
  377.     cookie_fun XHDI = get_fun_ptr ();
  378.     LONG oldstack = 0;
  379.     LONG ret;
  380.     
  381.     if (!Super ((void *)1L)) oldstack = Super (0L);
  382.     
  383.     ret = XHDI (19, major, minor);
  384.         
  385.     if (oldstack) Super ((void *)oldstack);
  386.     return ret;
  387. }
  388.  
  389.  
  390.  
  391. void
  392. XHMakeName (UWORD major, UWORD minor, ULONG start_sector, char *name)
  393. {
  394.     if (major < 8)
  395.     {
  396.         sprintf (name, "ACSI.%d.%d.%ld", major, minor, start_sector);
  397.         return;
  398.     }    
  399.  
  400.     if (major < 16)
  401.     {
  402.         sprintf (name, "SCSI.%d.%d.%ld", major - 8, minor,
  403.             start_sector);
  404.         return;
  405.     }    
  406.  
  407.     if (major < 18)
  408.     {
  409.         sprintf (name, "IDE.%d.%ld", major - 16, start_sector);
  410.         return;
  411.     }    
  412.  
  413.     if (major == 64)
  414.     {
  415.         sprintf (name, "FD.%d.%ld", minor, start_sector);
  416.         return;
  417.     }    
  418.     
  419.     sprintf (name, "XHDI.%d.%d.%ld", major, minor, start_sector);
  420. }
  421.